import Config from "@/base/Config";

/**
 * 字符串工具类
 * 
 * @author jn
 */
export class StringUtils {
    /** 空字符串 */
    private static readonly NULLSTR = "";

    /** 下划线 */
    // private static readonly SEPARATOR = "_";

    /**
     * 获取参数不为空值
     * @param value 要判断的value
     * @param defaultv defaultValue 
     * @returns value 返回值
     */
    static nvl(value: string, defaultv: string) {
        return value != null ? value : defaultv;

    }

    /**
     * 两个参数对比
     * 
     * @param cs1 1
     * @param cs2 2
     * @returns 
     */
    static equals(cs1: any, cs2: any) {
        if (cs1 == cs2) {
            return true;
        }
        if (cs1 == null || cs2 == null) {
            return false;
        }
        if (cs1.length != cs2.length) {
            return false;
        }
        if (cs1 instanceof String && cs2 instanceof String) {
            return cs1 == cs2;
        }
        // Step-wise comparison
        let length = cs1.length;
        for (let i = 0; i < length; i++) {
            if (cs1.charAt(i) != cs2.charAt(i)) {
                return false;
            }
        }
        return true;
    }

    /**
     * * 判断一个字符串是否为空串
     * 
     * @param str String
     * @return true：为空 false：非空
     */
    static isEmpty(str: any) {
        return this.isNull(str) || this.isisEmpty(str);
    }

    static isisEmpty(str: any) {
        return this.NULLSTR == str.toString().trim();
    }

    /**
     * * 判断一个字符串是否为空串
     * 
     * @param str String
     * @return true：为空 false：非空
     */
    static isNotEmpty(str: any) {
        return !StringUtils.isEmpty(str);
    }

    /**
     * * 判断一个对象是否为空
     * 
     * @param object Object
     * @return true：为空 false：非空
     */
    static isNull(object: any) {
        return object == null;
    }

    /**
     * * 判断一个对象是否非空
     * 
     * @param object Object
     * @return true：非空 false：空
     */
    static isNotNull(object: any) {
        return !StringUtils.isNull(object);
    }

    /**
     * 格式化文本, {} 表示占位符<br>
     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
     * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
     * 例：<br>
     * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
     * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
     * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
     * 
     * @param template 文本模板，被替换的部分用 {} 表示
     * @param params 参数值
     * @return 格式化后的文本
     */
    public static format(template: string, ...params: any) {
        if (this.isEmpty(params) || this.isEmpty(template)) {
            return template;
        }
        return "StrFormatter.format(template, params);"
    }

    /**
     * 是否为http(s)://开头
     * 
     * @param link 链接
     * @return 结果
     */
    static ishttp(link: string) {
        return StringUtils.startsWithAny(link);
    }

    /**
     * 头部是否为域名
     * @param link 域名
     * @returns 是否
     */
    static startsWithAny(link: string) {
        if (StringUtils.isEmpty(link)) {
            return false
        }
        if (Config.User.START_WITH_HTTP.test(link)) {
            return true
        }
        return false
    }

    /**
     * 首字母验证
     * 
     * @param str 字符串
     * @returns 首字母大写
     */
    static capitalize(str: string) {
        let strLen = str.toString();
        if (strLen.length == 0) {
            return strLen
        }

        let fs = strLen.codePointAt(0) as number;
        if (fs >= 65 && fs <= 90) {
            return strLen
        }

        return strLen.slice(0, 1).toUpperCase() + strLen.slice(1)
    }

    static isNotBlank(cs: string) {
        return !this.isBlank(cs);
    }

    static isBlank(cs: string) {
        let strLen: number = this.length1(cs);
        if (strLen == 0) {
            return true;
        }
        for (let i = 0; i < strLen; i++) {
            if (!(strLen.toString().charAt(i) == "")) {
                return false;
            }
        }
        return true;
    }

    
    static length1(cs: any) {
        return cs == null ? 0 : cs.length;
    }
}